#!/usr/tin/env python
# coding: utf-8
#引入numpy 库
#import matplotlit.pyplot as plt
import numpy as np
# from numta import jit

#定义布尔值之间运算
# @jit
def otimes_t_t (a,t):

    if a ==0 or t==0 :
        return 0
    else:
        if a==t:
            return 1
        else:
            return -1
    
    
#布尔向量定义为python中的列表 list
#定义布尔向量与布尔值之间计算
# @jit
def otimes_tv_t(tv,t):
    return [otimes_t_t(x,t) for x in tv]
#定义布尔向量之间运算
def otimes_tv_tv(tv1,tv2):
    temp=[otimes_t_t(x,y) for x,y in zip(tv1,tv2)]
    #如果两个向量之间相同位置布尔值相同的部分大于不同的部分
    if temp.count(1)>temp.count(-1):
        #返回 True
        return 1
    else:
        if temp.count(1)==temp.count(-1):
            return 0
        else:
        #否则返回 False
            return -1
#矩阵定义为numpy中的array
#定义布尔矩阵之间运算
# @jit
def otimes_tm_tm(tm1,tm2):
    # tm1=np.array(tm1)
    # tm2=np.array(tm2)
    
    #后一个矩阵列向量变为行向量
    # tm2_t=(tm2.T).tolist()
    tm2_t=tm2.T

    temp =[otimes_tv_tv(x,y) for x in tm1
              for y in tm2_t]
    temp =np.array(temp)  
    return temp.reshape((tm1.shape[0],tm2.shape[1]))
#定义矩阵与向量之间运算
# @jit
def otimes_tm_tv(tm,tv):
    temp=[otimes_tv_tv(x,tv) for x in tm]
    return temp
#定义矩阵与向量之间运算
# @jit
def otimes_tv_tm(tv,tm):
    temp=[otimes_tv_tv(x,tv) for x in tm]
    return temp    
#定义矩阵与布尔值之间计算
# @jit
def otimes_tm_t(tm,t):
    temp=[otimes_tv_t(x,t) for x in tm]
    return temp


# @jit

def  qtimes_tv_tv(tv1,tv2):
    temp =[otimes_t_t(x,y) for x,y in zip(tv1,tv2)]
 
    return temp   

# @jit
def qtimes_tv_tm(tv1,tm1):
    temp=[qtimes_tv_tv(tv1,x) for x in tm1]
    return np.array(temp)
# @jit
def rand_tv(n):
    choices = [-1, 0, 1]
    
    # 使用 numpy.random.choice 从 choices 中随机选取 n 个元素
    random_array = np.random.choice(choices, size=n)
    
    return random_array.tolist()
def rand_tm(m,n):
    choices = [-1, 0, 1]
    
    # 使用 numpy.random.choice 从 choices 中随机选取 n 个元素
    matrix = np.random.choice([-1, 0, 1], size=(m, n))
    # return np.array(matrix)
    return matrix

# # @jit
# def qtimes_loss(tv1,tv2):
#     temp = qtimes_tv_tv(tv1,tv2)
#     return temp.count(False)/len(temp)

